package com.tbsoft.ehr.util;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.concurrent.TimeoutException;

public class ProcessUtils {
	 /**
     * 运行一个外部命令，返回状态.若超过指定的超时时间，抛出TimeoutException
     * @param command
     * @param timeout
     * @return
     * @throws IOException
     * @throws InterruptedException
     * @throws TimeoutException
     */
    public static int executeCommand(final String command, final long timeout) throws IOException, InterruptedException, TimeoutException {
        Process process = Runtime.getRuntime().exec(command);
        //获取进程的标准输入流  
        final InputStream is1 = process.getInputStream();   
        //获取进城的错误流  
        final InputStream is2 = process.getErrorStream();  
        //启动两个线程，一个线程负责读标准输出流，另一个负责读标准错误流  
        new Thread() {  
           public void run() {  
              BufferedReader br1 = new BufferedReader(new InputStreamReader(is1));  
               try {  
                   String line1 = null;  
                   while ((line1 = br1.readLine()) != null) {  
                         if (line1 != null){}  
                     }  
               } catch (IOException e) {  
                    e.printStackTrace();  
               }  
               finally{  
                    try {  
                      is1.close();  
                    } catch (IOException e) {  
                       e.printStackTrace();  
                   }  
                 }  
               }  
            }.start();  
                                       
          new Thread() {   
             public void  run() {   
              BufferedReader br2 = new  BufferedReader(new  InputStreamReader(is2));   
                 try {   
                    String line2 = null ;   
                    while ((line2 = br2.readLine()) !=  null ) {   
                         if (line2 != null){}  
                    }   
                  } catch (IOException e) {   
                        e.printStackTrace();  
                  }   
                 finally{  
                    try {  
                        is2.close();  
                    } catch (IOException e) {  
                        e.printStackTrace();  
                    }  
                  }  
               }   
             }.start();    
        Worker worker = new Worker(process);
        worker.start();
        try {
            worker.join(timeout);
            if (worker.exit != null){
                return worker.exit;
            } else{
                throw new TimeoutException();
            }
        } catch (InterruptedException ex) {
            worker.interrupt();
            Thread.currentThread().interrupt();
            throw ex;
        } finally {
            process.destroy();
        }
    }
   

    private static class Worker extends Thread {
        private final Process process;
        private Integer exit;

        private Worker(Process process) {
            this.process = process;
        }

        public void run() {
            try {
                exit = process.waitFor();
            } catch (InterruptedException ignore) {
                return;
            }
        }
    }
}
